home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / x / volume14 / olvwm / patch2.03 < prev    next >
Encoding:
Text File  |  1991-08-26  |  47.7 KB  |  1,647 lines
  1. Path: uunet!cs.utexas.edu!sun-barr!cronkite.Central.Sun.COM!exodus!soliado.East.Sun.COM
  2. From: sdo@soliado.East.Sun.COM (Scott Oaks - Sun Consulting NYC)
  3. Newsgroups: comp.sources.x
  4. Subject: v14i009: olvwm - Open Look Virtual Window Manager, Patch2, Part03/03
  5. Message-ID: <19075@exodus.Eng.Sun.COM>
  6. Date: 27 Aug 91 06:00:48 GMT
  7. References: <csx-14i007-olvwm@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1635
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: sdo@soliado.East.Sun.COM (Scott Oaks - Sun Consulting NYC)
  13. Posting-number: Volume 14, Issue 9
  14. Archive-name: olvwm/patch2.03
  15. Patch-To: olvwm:  Volume 12, Issues 57-72 
  16. Patch-To: olvwm:  Volume 14, Issues 6
  17.  
  18. *** build/virtual.c    Sat Jun 22 20:09:31 1991
  19. --- src/virtual.c    Sat Jun 22 20:56:20 1991
  20. ***************
  21. *** 12,19 ****
  22.   #include "defaults.h"
  23.   #include "resources.h"
  24.   #include "st.h"
  25.   
  26. ! static char     sccsid[] = "@(#)virtual.c    1.3 olvwm version 4/17/91";
  27.   
  28.   #define TRUE    (1)
  29.   #define FALSE    (0)
  30. --- 12,22 ----
  31.   #include "defaults.h"
  32.   #include "resources.h"
  33.   #include "st.h"
  34. + #include "menu.h"
  35. + #include "list.h"
  36. + #include "patchlevel.h"
  37.   
  38. ! static char     sccsid[] = "@(#)virtual.c    1.4 olvwm version 6/22/91";
  39.   
  40.   #define TRUE    (1)
  41.   #define FALSE    (0)
  42. ***************
  43. *** 36,69 ****
  44.   int    VDMWidth, VDMHeight;
  45.   int    VDMOutlineX, VDMOutlineY;
  46.   int    VDMOutlineWidth, VDMOutlineHeight;
  47.   extern long WorkspaceColorPixel;
  48.   
  49.   int    VirtualBackgroundColorSet = FALSE;
  50.   int    VirtualForegroundColorSet = FALSE;
  51.   int    VirtualFontColorSet = FALSE;
  52.   
  53.   extern GC RootGC;
  54.   static GC    VDMGC = NULL;
  55.   
  56.   MakeVirtualDesktop(dpy)
  57.       Display    *dpy;
  58.   
  59.   {
  60.       int    width, height;
  61.   
  62.       sscanf(GRV.VirtualDesktop, "%dx%d", &width, &height);
  63. !     if (width < DisplayWidth(dpy,DefaultScreen(dpy)))
  64. !        width = width * DisplayWidth(dpy,DefaultScreen(dpy));
  65. !     if (height < DisplayHeight(dpy,DefaultScreen(dpy)))
  66. !        height = height * DisplayHeight(dpy,DefaultScreen(dpy));
  67.   
  68. !     VirtualDesktopWidth = width;
  69. !     VirtualDesktopHeight = height;
  70.       VirtualDesktopX = 0;
  71.       VirtualDesktopY = 0;
  72.       VirtualContext = XUniqueContext();
  73.   }
  74.   
  75.   MakeVDM(dpy)
  76.       Display    *dpy;
  77.   
  78. --- 39,163 ----
  79.   int    VDMWidth, VDMHeight;
  80.   int    VDMOutlineX, VDMOutlineY;
  81.   int    VDMOutlineWidth, VDMOutlineHeight;
  82. + int    VDMRows, VDMCols;
  83.   extern long WorkspaceColorPixel;
  84.   
  85.   int    VirtualBackgroundColorSet = FALSE;
  86.   int    VirtualForegroundColorSet = FALSE;
  87.   int    VirtualFontColorSet = FALSE;
  88. + int    VirtualGridColorSet = False;
  89.   
  90.   extern GC RootGC;
  91.   static GC    VDMGC = NULL;
  92.   
  93. + static int VDMMenuAction();
  94. + 
  95. + List    *VWList = NULL_LIST;
  96. + 
  97. + static Button VDMButtons[] = {
  98. + #define VDM_MENU_RIGHT    0
  99. +     { "Move Right", False, Enabled, {VDMMenuAction, (void *) NULL} },
  100. + #define VDM_MENU_LEFT    1
  101. +     { "Move Left", False, Enabled, {VDMMenuAction, (void *) NULL} },
  102. + #define VDM_MENU_UP    2
  103. +     { "Move Up", False, Enabled, {VDMMenuAction, (void *) NULL} },
  104. + #define VDM_MENU_DOWN    3
  105. +     { "Move Down", False, Enabled, {VDMMenuAction, (void *) NULL} },
  106. + #define VDM_MENU_RIGHT_UP    4
  107. +     { "Move Right/Up", False, Enabled, {VDMMenuAction, (void *) NULL} },
  108. + #define VDM_MENU_RIGHT_DOWN    5
  109. +     { "Move Right/Down", False, Enabled, {VDMMenuAction, (void *) NULL} },
  110. + #define VDM_MENU_LEFT_UP    6
  111. +     { "Move Left/Up", False, Enabled, {VDMMenuAction, (void *) NULL} },
  112. + #define VDM_MENU_LEFT_DOWN    7
  113. +     { "Move Left/Down", False, Enabled, {VDMMenuAction, (void *) NULL} },
  114. + #define VDM_MENU_HOME    8
  115. +     { "Move Home", False, Enabled, {VDMMenuAction, (void *) NULL} },
  116. + };
  117. + 
  118. + Menu VDMMenu = { "OLVWM 2.1", VDMButtons, 9, -0, True, (FuncPtr) MakeMenu};
  119. + 
  120. + #define VDMSelectMask (ButtonPressMask | ButtonReleaseMask | \
  121. +             KeyPressMask | KeyReleaseMask | \
  122. +             PointerMotionMask | ExposureMask | StructureNotifyMask)
  123. + 
  124.   MakeVirtualDesktop(dpy)
  125.       Display    *dpy;
  126.   
  127.   {
  128.       int    width, height;
  129. +     char temp[4];
  130. +     int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  131. +     int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  132. +     static int done_menu = False;
  133.   
  134.       sscanf(GRV.VirtualDesktop, "%dx%d", &width, &height);
  135. !     if (width < dw)
  136. !         VDMCols = width;
  137. !     else VDMCols = ceil((double) width / dw);
  138. !     if (height < dh)
  139. !     VDMRows = height;
  140. !     else VDMRows = ceil((double) height / dh);
  141.   
  142. !     VirtualDesktopWidth = VDMCols * dw;
  143. !     VirtualDesktopHeight = VDMRows * dh;
  144.       VirtualDesktopX = 0;
  145.       VirtualDesktopY = 0;
  146.       VirtualContext = XUniqueContext();
  147. + 
  148. +     VDMOutlineWidth = ceil((double) dw / GRV.VDMScale);
  149. +     VDMOutlineHeight = ceil((double) dh / GRV.VDMScale);
  150. +     if (GRV.VirtualGrid) {
  151. +         VDMWidth = VDMCols * VDMOutlineWidth;
  152. +         VDMHeight = VDMRows * VDMOutlineHeight;
  153. +     }
  154. +     else {
  155. +     VDMWidth = VirtualDesktopWidth / GRV.VDMScale;
  156. +     VDMHeight = VirtualDesktopHeight / GRV.VDMScale;
  157. +     }
  158. +     VDMOutlineX = 0;
  159. +     VDMOutlineY = 0;
  160. + 
  161. +     if (!done_menu) {
  162. +         sprintf(temp, "%0d", PATCHLEVEL);
  163. +         width = strlen(VDMMenu.title);
  164. +         VDMMenu.title[width - 1] = temp[0];
  165. +         MenuCreate(dpy, &VDMMenu);
  166. +     done_menu = True;
  167. +     }
  168.   }
  169.   
  170. + VDMGrabKey(dpy, keysym)
  171. +     Display    *dpy;
  172. +     int        keysym;
  173. + 
  174. + {
  175. + int    keycode;
  176. + static int meta_mask = 0, shift_mask, control_mask;
  177. + 
  178. +     if (meta_mask == 0) {
  179. +         keycode = XKeysymToKeycode(dpy, XK_Meta_L);
  180. +         meta_mask = FindModifierMask(keycode);
  181. +     if (meta_mask == 0)
  182. +         return;
  183. +         keycode = XKeysymToKeycode(dpy, XK_Shift_L);
  184. +         shift_mask = FindModifierMask(keycode);
  185. +         keycode = XKeysymToKeycode(dpy, XK_Control_L);
  186. +         control_mask = FindModifierMask(keycode);
  187. +     }
  188. +     keycode = XKeysymToKeycode(dpy, keysym);
  189. +     if (keycode == 0)
  190. +     return;
  191. +     XGrabKey(dpy, keycode, meta_mask,
  192. +           DefaultRootWindow(dpy), False, GrabModeAsync, GrabModeAsync);
  193. +     XGrabKey(dpy, keycode, meta_mask | shift_mask,
  194. +           DefaultRootWindow(dpy), False, GrabModeAsync, GrabModeAsync);
  195. +     XGrabKey(dpy, keycode, meta_mask | control_mask,
  196. +           DefaultRootWindow(dpy), False, GrabModeAsync, GrabModeAsync);
  197. +     XGrabKey(dpy, keycode, meta_mask | control_mask | shift_mask,
  198. +           DefaultRootWindow(dpy), False, GrabModeAsync, GrabModeAsync);
  199. + }
  200. + 
  201.   MakeVDM(dpy)
  202.       Display    *dpy;
  203.   
  204. ***************
  205. *** 76,120 ****
  206.       XSizeHints *sizeHints;
  207.       XWMHints *wmHints;
  208.       XClassHint *classHints;
  209. !     int x, y, width, height, dummy, flags;
  210.       Pixmap pm = None;
  211.       unsigned attrMask;
  212. !  
  213. !     width = VirtualDesktopWidth / GRV.VDMScale + 1;
  214. !     height = VirtualDesktopHeight / GRV.VDMScale + 1;
  215.   
  216.       sizeHints = XAllocSizeHints();
  217.       sizeHints->flags = PBaseSize;
  218. !     sizeHints->base_width = width;
  219. !     sizeHints->base_height = height;
  220. !     sizeHints->min_width = DisplayWidth(dpy, DefaultScreen(dpy)) /
  221. !                 GRV.VDMScale + 1;
  222. !     sizeHints->min_height = DisplayHeight(dpy, DefaultScreen(dpy)) /
  223. !                 GRV.VDMScale + 1;
  224. !     sizeHints->flags = USPosition|PMinSize;
  225.       flags = XParseGeometry(GRV.VirtualGeometry, &x, &y, &dummy, &dummy);
  226.       if (flags & XValue)
  227.       if (flags & XNegative)
  228.           sizeHints->x =
  229. !         DisplayWidth(dpy, DefaultScreen(dpy)) + x - width;
  230.       else sizeHints->x = x;
  231.       else sizeHints->x = 0;
  232.       if (flags & YValue)
  233.       if (flags & YNegative)
  234.           sizeHints->y =
  235. !         DisplayHeight(dpy, DefaultScreen(dpy)) + y - height;
  236.       else sizeHints->y = y;
  237.       else sizeHints->y = 0;
  238. !     if (sizeHints->x > DisplayWidth(dpy, DefaultScreen(dpy)) - width)
  239. !     sizeHints->x = DisplayWidth(dpy, DefaultScreen(dpy)) - width;
  240. !     if (sizeHints->y > DisplayHeight(dpy, DefaultScreen(dpy)) - height)
  241. !     sizeHints->y = DisplayHeight(dpy, DefaultScreen(dpy)) - height;
  242.          
  243.       wmHints = XAllocWMHints();
  244.       if (GRV.VirtualIconic)
  245.       wmHints->initial_state = IconicState;
  246.       else wmHints->initial_state = NormalState;
  247. !     wmHints->flags = StateHint | InputHint | IconPixmapHint | IconPositionHint;
  248.       wmHints->input = TRUE;
  249.       wmHints->icon_pixmap = XCreateBitmapFromData(dpy,
  250.           DefaultRootWindow(dpy), vdm_bits,
  251. --- 170,215 ----
  252.       XSizeHints *sizeHints;
  253.       XWMHints *wmHints;
  254.       XClassHint *classHints;
  255. !     int x, y, dummy, flags;
  256.       Pixmap pm = None;
  257.       unsigned attrMask;
  258. !     int    keysym;
  259. !     char dashList[2];
  260.   
  261.       sizeHints = XAllocSizeHints();
  262.       sizeHints->flags = PBaseSize;
  263. !     sizeHints->base_width = VDMWidth;
  264. !     sizeHints->base_height = VDMHeight;
  265. !     sizeHints->min_width = VDMOutlineWidth;
  266. !     sizeHints->min_height = VDMOutlineHeight;
  267. !     sizeHints->width_inc = VDMOutlineWidth;
  268. !     sizeHints->height_inc = VDMOutlineHeight;
  269. !     if (GRV.VirtualGrid)
  270. !     sizeHints->flags = USPosition | PMinSize | PResizeInc;
  271. !     else sizeHints->flags = USPosition|PMinSize;
  272.       flags = XParseGeometry(GRV.VirtualGeometry, &x, &y, &dummy, &dummy);
  273.       if (flags & XValue)
  274.       if (flags & XNegative)
  275.           sizeHints->x =
  276. !         DisplayWidth(dpy, DefaultScreen(dpy)) + x - VDMWidth;
  277.       else sizeHints->x = x;
  278.       else sizeHints->x = 0;
  279.       if (flags & YValue)
  280.       if (flags & YNegative)
  281.           sizeHints->y =
  282. !         DisplayHeight(dpy, DefaultScreen(dpy)) + y - VDMHeight;
  283.       else sizeHints->y = y;
  284.       else sizeHints->y = 0;
  285. !     if (sizeHints->x > DisplayWidth(dpy, DefaultScreen(dpy)) - VDMWidth)
  286. !     sizeHints->x = DisplayWidth(dpy, DefaultScreen(dpy)) - VDMWidth;
  287. !     if (sizeHints->y > DisplayHeight(dpy, DefaultScreen(dpy)) - VDMHeight)
  288. !     sizeHints->y = DisplayHeight(dpy, DefaultScreen(dpy)) - VDMHeight;
  289.          
  290.       wmHints = XAllocWMHints();
  291.       if (GRV.VirtualIconic)
  292.       wmHints->initial_state = IconicState;
  293.       else wmHints->initial_state = NormalState;
  294. !     wmHints->flags = StateHint | InputHint | IconPixmapHint;
  295.       wmHints->input = TRUE;
  296.       wmHints->icon_pixmap = XCreateBitmapFromData(dpy,
  297.           DefaultRootWindow(dpy), vdm_bits,
  298. ***************
  299. *** 121,140 ****
  300.           vdm_width, vdm_height,
  301.           GRV.Fg1Color, GRV.Bg1Color, 1);
  302.       flags = XParseGeometry(GRV.VirtualIconGeometry, &x, &y, &dummy, &dummy);
  303. !     if (flags & XValue)
  304. !     if (flags & XNegative)
  305. !         wmHints->icon_x = DisplayWidth(dpy, DefaultScreen(dpy)) + x - ICON_SIZE;
  306. !     else wmHints->icon_x = x;
  307. !     else wmHints->icon_x = 0;
  308. !     if (flags & YValue)
  309. !     if (flags & YNegative)
  310. !         wmHints->icon_y = DisplayHeight(dpy, DefaultScreen(dpy)) + y - ICON_SIZE;
  311. !     else wmHints->icon_y = y;
  312. !     else wmHints->icon_y = 0;
  313. !     if (wmHints->icon_x > DisplayWidth(dpy, DefaultScreen(dpy)) - ICON_SIZE)
  314. !     wmHints->icon_x = DisplayWidth(dpy, DefaultScreen(dpy)) - ICON_SIZE;
  315. !     if (wmHints->icon_y > DisplayHeight(dpy, DefaultScreen(dpy)) - ICON_SIZE)
  316. !     wmHints->icon_y = DisplayHeight(dpy, DefaultScreen(dpy)) - ICON_SIZE;
  317.    
  318.       classHints = XAllocClassHint();
  319.       classHints->res_name = "virtualDesktop";
  320. --- 216,240 ----
  321.           vdm_width, vdm_height,
  322.           GRV.Fg1Color, GRV.Bg1Color, 1);
  323.       flags = XParseGeometry(GRV.VirtualIconGeometry, &x, &y, &dummy, &dummy);
  324. !     if (flags & (XValue | YValue)) {
  325. !         if (flags & XValue)
  326. !         if (flags & XNegative)
  327. !             wmHints->icon_x = DisplayWidth(dpy, DefaultScreen(dpy)) +
  328. !                     x - ICON_SIZE;
  329. !         else wmHints->icon_x = x;
  330. !         else wmHints->icon_x = 0;
  331. !         if (flags & YValue)
  332. !         if (flags & YNegative)
  333. !             wmHints->icon_y = DisplayHeight(dpy, DefaultScreen(dpy)) +
  334. !                     y - ICON_SIZE;
  335. !         else wmHints->icon_y = y;
  336. !         else wmHints->icon_y = 0;
  337. !         if (wmHints->icon_x > DisplayWidth(dpy, DefaultScreen(dpy)) - ICON_SIZE)
  338. !         wmHints->icon_x = DisplayWidth(dpy, DefaultScreen(dpy)) - ICON_SIZE;
  339. !         if (wmHints->icon_y > DisplayHeight(dpy, DefaultScreen(dpy)) - ICON_SIZE)
  340. !         wmHints->icon_y = DisplayHeight(dpy, DefaultScreen(dpy)) - ICON_SIZE;
  341. !     wmHints->flags |= IconPositionHint;
  342. !     }
  343.    
  344.       classHints = XAllocClassHint();
  345.       classHints->res_name = "virtualDesktop";
  346. ***************
  347. *** 159,180 ****
  348.       XCopyGC(dpy, RootGC, GCFunction | GCPlaneMask | GCForeground |
  349.                   GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |
  350.                   GCJoinStyle | GCFillRule | GCFont, VDMGC);
  351. !     XSetFunction(dpy, VDMGC, GXset);
  352.       XSetFont(dpy, VDMGC, GRV.VirtualFont->fid);
  353.       if (VirtualFontColorSet)
  354.       XSetForeground(dpy, VDMGC, GRV.VirtualFontColor);
  355.       if (VirtualForegroundColorSet)
  356.       XSetBackground(dpy, VDMGC, GRV.VirtualForegroundColor);
  357.       else XSetBackground(dpy, VDMGC, GRV.Bg1Color);
  358. -     if (GRV.VirtualBackgroundMap) {
  359. -     if (pm != None)
  360. -         XFreePixmap(dpy, pm);
  361. -     if (pm = CreateVirtualPixmap(dpy)) {
  362. -         attrMask &= ~CWBackPixel;
  363. -             attrMask |= CWBackPixmap;
  364. -         attr.background_pixmap = pm;
  365. -     }
  366. -     }
  367.   
  368.       VDM = XCreateWindow(dpy, RootWindow(dpy, DefaultScreen(dpy)),
  369.           sizeHints->x, sizeHints->y,
  370. --- 259,274 ----
  371.       XCopyGC(dpy, RootGC, GCFunction | GCPlaneMask | GCForeground |
  372.                   GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |
  373.                   GCJoinStyle | GCFillRule | GCFont, VDMGC);
  374. !     XSetFunction(dpy, VDMGC, GXcopy);
  375.       XSetFont(dpy, VDMGC, GRV.VirtualFont->fid);
  376. +     dashList[0] = 0;
  377. +     dashList[1] = 1;
  378. +     XSetDashes( dpy, VDMGC, 1, dashList, 2);
  379.       if (VirtualFontColorSet)
  380.       XSetForeground(dpy, VDMGC, GRV.VirtualFontColor);
  381.       if (VirtualForegroundColorSet)
  382.       XSetBackground(dpy, VDMGC, GRV.VirtualForegroundColor);
  383.       else XSetBackground(dpy, VDMGC, GRV.Bg1Color);
  384.   
  385.       VDM = XCreateWindow(dpy, RootWindow(dpy, DefaultScreen(dpy)),
  386.           sizeHints->x, sizeHints->y,
  387. ***************
  388. *** 181,200 ****
  389.               sizeHints->base_width, sizeHints->base_height, 1,
  390.               DefaultDepth(dpy, DefaultScreen(dpy)), InputOutput,
  391.               CopyFromParent, attrMask, &attr);
  392.       if (pm != None)
  393.       XFreePixmap(dpy, pm);
  394.   
  395. -     VDMWidth = sizeHints->base_width;
  396. -     VDMHeight = sizeHints->base_height;
  397. -     VDMOutlineWidth = VDMWidth /
  398. -             ((width * GRV.VDMScale) /
  399. -                 DisplayWidth(dpy,DefaultScreen(dpy)));
  400. -     VDMOutlineHeight = VDMHeight /
  401. -             ((height * GRV.VDMScale)
  402. -                 / DisplayHeight(dpy,DefaultScreen(dpy)));
  403. -     VDMOutlineX = 0;
  404. -     VDMOutlineY = 0;
  405. - 
  406.       XSetWMProperties(dpy, VDM, &wName, &iName, NULL, 0,
  407.           sizeHints, wmHints, classHints);
  408.       XFree(sizeHints);
  409. --- 275,293 ----
  410.               sizeHints->base_width, sizeHints->base_height, 1,
  411.               DefaultDepth(dpy, DefaultScreen(dpy)), InputOutput,
  412.               CopyFromParent, attrMask, &attr);
  413. +     /*
  414. +      * Have to do this after the VDM is created because of the GC stuff
  415. +      */
  416. +     if (GRV.VirtualBackgroundMap) {
  417. +     if (pm != None)
  418. +         XFreePixmap(dpy, pm);
  419. +     if (pm = CreateVirtualPixmap(dpy))
  420. +         XSetWindowBackgroundPixmap(dpy, VDM, pm);
  421. +     }
  422. +     VWList = ListCons(VDM, VWList);
  423.       if (pm != None)
  424.       XFreePixmap(dpy, pm);
  425.   
  426.       XSetWMProperties(dpy, VDM, &wName, &iName, NULL, 0,
  427.           sizeHints, wmHints, classHints);
  428.       XFree(sizeHints);
  429. ***************
  430. *** 202,207 ****
  431. --- 295,314 ----
  432.       XFree(classHints);
  433.       XMapRaised(dpy, VDM);
  434.   
  435. +     if (!GRV.GrabVirtualKeys)
  436. +     return;
  437. +     for (keysym = XK_R7; keysym <= XK_R15; keysym++)
  438. +     VDMGrabKey(dpy, keysym);
  439. +     /*
  440. +      * Why don't these arrow keys map to R8, R10, R12, R14
  441. +      */
  442. +     VDMGrabKey(dpy, XK_Left);
  443. +     VDMGrabKey(dpy, XK_Right);
  444. +     VDMGrabKey(dpy, XK_Down);
  445. +     VDMGrabKey(dpy, XK_Up);
  446. + 
  447. +     for (keysym = XK_F1; keysym <= XK_F10; keysym++)
  448. +     VDMGrabKey(dpy, keysym);
  449.   }
  450.   
  451.   VirtualSetUpFrame(cli, frame)
  452. ***************
  453. *** 226,233 ****
  454.           GFrameSetConfig(cli->framewin, cli->framewin->core.x - dx,
  455.           cli->framewin->core.y - dy,
  456.           cli->framewin->core.width, cli->framewin->core.height);
  457. -     /*cli->framewin->core.x -= dx;
  458. -     cli->framewin->core.y -= dy;*/
  459.       }
  460.   }
  461.   
  462. --- 333,338 ----
  463. ***************
  464. *** 269,277 ****
  465.       virtual = XCreateSimpleWindow(dpy, VDM, x, y,
  466.       width, height, 1, GRV.BorderColor, 
  467.       VirtualForegroundColorSet ? GRV.VirtualForegroundColor : GRV.Bg1Color);
  468.       if (PANEWINOFCLIENT(cli) != VDM)
  469. !         XSelectInput(dpy, virtual, ButtonPressMask | ExposureMask);
  470. !     else XSelectInput(dpy, virtual, ExposureMask);
  471.       XSaveContext(dpy, virtual, VirtualContext, cli);
  472.       cli->virtualWindow = virtual;
  473.       cli->virtualInactive = MakeVirtualIcon(cli, dpy);
  474. --- 374,383 ----
  475.       virtual = XCreateSimpleWindow(dpy, VDM, x, y,
  476.       width, height, 1, GRV.BorderColor, 
  477.       VirtualForegroundColorSet ? GRV.VirtualForegroundColor : GRV.Bg1Color);
  478. +     VWList = ListCons(virtual, VWList);
  479.       if (PANEWINOFCLIENT(cli) != VDM)
  480. !         XSelectInput(dpy, virtual, VDMSelectMask);
  481. !     else XSelectInput(dpy, virtual, ExposureMask | StructureNotifyMask);
  482.       XSaveContext(dpy, virtual, VirtualContext, cli);
  483.       cli->virtualWindow = virtual;
  484.       cli->virtualInactive = MakeVirtualIcon(cli, dpy);
  485. ***************
  486. *** 309,315 ****
  487.       if (XFindContext(dpy, ev->xany.window, VirtualContext, &cli) != 0)
  488.       return;        /* Window is destroyed . . . */
  489.   
  490. !     XClearArea(dpy, ev->xany.window, 1, 1, 0, 0, False);
  491.       XDrawImageString(dpy, ev->xany.window, VDMGC, 1, 
  492.                   GRV.VirtualFont->max_bounds.ascent + 1,
  493.               cli->framewin->fcore.name,
  494. --- 415,421 ----
  495.       if (XFindContext(dpy, ev->xany.window, VirtualContext, &cli) != 0)
  496.       return;        /* Window is destroyed . . . */
  497.   
  498. !     XClearArea(dpy, ev->xany.window, 0, 0, 0, 0, False);
  499.       XDrawImageString(dpy, ev->xany.window, VDMGC, 1, 
  500.                   GRV.VirtualFont->max_bounds.ascent + 1,
  501.               cli->framewin->fcore.name,
  502. ***************
  503. *** 339,345 ****
  504.       virtual = XCreateSimpleWindow(dpy, VDM, x, y,
  505.           width, height, 1, GRV.BorderColor,
  506.       VirtualForegroundColorSet ? GRV.VirtualForegroundColor : GRV.Bg1Color);
  507. !     XSelectInput(dpy, virtual, ButtonPressMask | KeyPressMask | ExposureMask);
  508.       XSaveContext(dpy, virtual, VirtualContext, cli);
  509.       return virtual;
  510.   }
  511. --- 445,452 ----
  512.       virtual = XCreateSimpleWindow(dpy, VDM, x, y,
  513.           width, height, 1, GRV.BorderColor,
  514.       VirtualForegroundColorSet ? GRV.VirtualForegroundColor : GRV.Bg1Color);
  515. !     VWList = ListCons(virtual, VWList);
  516. !     XSelectInput(dpy, virtual, VDMSelectMask);
  517.       XSaveContext(dpy, virtual, VirtualContext, cli);
  518.       return virtual;
  519.   }
  520. ***************
  521. *** 354,364 ****
  522.       if (ev->xexpose.count)
  523.       return;
  524.   
  525.       XClearArea(dpy, VDM, 0, 0, 0, 0, 0);
  526.       XDrawRectangle(dpy, VDM, VDMGC,
  527. !            VDMOutlineX, VDMOutlineY,
  528. !            VDMOutlineWidth, VDMOutlineHeight);
  529. !     while (XCheckTypedWindowEvent(dpy, VDM, Expose, &dummy));
  530.   }
  531.   
  532.   VDMEvents(dpy, ev)
  533. --- 461,502 ----
  534.       if (ev->xexpose.count)
  535.       return;
  536.   
  537. +     DrawVDMGrid(dpy);
  538. +     while (XCheckTypedWindowEvent(dpy, VDM, Expose, &dummy));
  539. + }
  540. + 
  541. + DrawVDMGrid(dpy)
  542. + Display *dpy;
  543. + 
  544. + {
  545. + int    i;
  546. + XPoint    pts[2];
  547. + 
  548.       XClearArea(dpy, VDM, 0, 0, 0, 0, 0);
  549. +     if (VirtualGridColorSet)
  550. +         XSetForeground(dpy, VDMGC, GRV.VirtualGridColor);
  551. +     if (GRV.VirtualGrid == 2) {
  552. +     XSetLineAttributes(dpy, VDMGC, 1, LineOnOffDash, CapNotLast, JoinMiter);
  553. +     pts[0].y = 0;
  554. +     pts[1].y = VDMHeight;
  555. +     for (i = 0; i < VDMWidth; i += VDMOutlineWidth) {
  556. +         pts[0].x = pts[1].x = i;
  557. +         XDrawLines(dpy, VDM, VDMGC, pts, 2, CoordModeOrigin);
  558. +     }
  559. +     pts[0].x = 0;
  560. +     pts[1].x = VDMWidth;
  561. +     for (i = 0; i < VDMHeight; i += VDMOutlineHeight) {
  562. +         pts[0].y = pts[1].y = i;
  563. +         XDrawLines(dpy, VDM, VDMGC, pts, 2, CoordModeOrigin);
  564. +     }
  565. +     XSetLineAttributes(dpy, VDMGC, 1, LineSolid, CapNotLast, JoinMiter);
  566. +     }
  567.       XDrawRectangle(dpy, VDM, VDMGC,
  568. !     VDMOutlineX, VDMOutlineY, VDMOutlineWidth, VDMOutlineHeight);
  569. !     if (VirtualGridColorSet)
  570. !     if (VirtualFontColorSet)
  571. !         XSetForeground(dpy, VDMGC, GRV.VirtualFontColor);
  572. !     else XSetForeground(dpy, VDMGC, GRV.Fg1Color);
  573.   }
  574.   
  575.   VDMEvents(dpy, ev)
  576. ***************
  577. *** 377,386 ****
  578.           XBell(dpy, 100);
  579.           break;
  580.       case ButtonPress:
  581. !         if (MouseButton(dpy, ev) != MB_SELECT)
  582. !         return;
  583. !         if (HandleVDMButtonPress(dpy, ev))
  584. !         state = 1;
  585.           break;
  586.       case ButtonRelease:
  587.           if (!state)
  588. --- 515,532 ----
  589.           XBell(dpy, 100);
  590.           break;
  591.       case ButtonPress:
  592. !         switch(MouseButton(dpy, ev)) {
  593. !         case MB_SELECT:
  594. !                 if (HandleVDMButtonPress(dpy, ev))
  595. !             state = 1;
  596. !             break;
  597. !         case MB_MENU:
  598. !                 MenuShow(dpy, NULL, &VDMMenu, ev);
  599. !             break;
  600. !         case MB_ADJUST:
  601. !             /* I really should do this someday . . .*/
  602. !             break;
  603. !         }
  604.           break;
  605.       case ButtonRelease:
  606.           if (!state)
  607. ***************
  608. *** 455,469 ****
  609.   }
  610.   #endif
  611.   
  612. ! IsVirtual(w)
  613.       Window    w;
  614.   
  615.   {
  616. !     if (w == VDM)
  617. !     return TRUE;
  618. !     if (!WIGetInfo(w))
  619. !     return TRUE;
  620. !     return FALSE;
  621.   }
  622.   
  623.   VirtualEvents(dpy, ev)
  624. --- 601,633 ----
  625.   }
  626.   #endif
  627.   
  628. ! FindVW(w1, w2)
  629. !     Window    w1, w2;
  630. ! 
  631. ! {
  632. !     if (w1 == w2)
  633. !     return w1;
  634. !     return NULL;
  635. ! }
  636. ! 
  637. ! IsVirtual(dpy, w)
  638. !     Display    *dpy;
  639.       Window    w;
  640.   
  641.   {
  642. ! Client    *cli;
  643. ! 
  644. !     if (ListApply(VWList, FindVW, w) != NULL) {
  645. !     if (XFindContext(dpy, w, VirtualContext, &cli) != 0)
  646. !         /*
  647. !          * REMIND:  Can this happen?  
  648. !          */
  649. !         return True;
  650. !     if (cli->wmState == IconicState)
  651. !         return cli->iconwin->core.self;
  652. !     else return cli->framewin->core.self;
  653. !     }
  654. !     return False;
  655.   }
  656.   
  657.   VirtualEvents(dpy, ev)
  658. ***************
  659. *** 472,477 ****
  660. --- 636,642 ----
  661.   
  662.   {
  663.   Client    *cli;
  664. + Window    dummy;
  665.   
  666.       if (ev->xany.window == VDM)
  667.       VDMEvents(dpy, ev);
  668. ***************
  669. *** 479,494 ****
  670.       case Expose:
  671.           PaintVirtualWindow(dpy, ev);
  672.           break;
  673. !     case ButtonPress:
  674.           /*
  675. !          * Really I should do a select here and then maybe move many, but
  676. !          * I'm too lazy
  677.            */
  678. !         if (MouseButton(dpy, ev) != MB_SELECT)
  679. !         return;
  680.           if (XFindContext(dpy, ev->xany.window, VirtualContext, &cli) != 0)
  681.           return;
  682. !         UserMoveVirtualWindow(dpy, ev, cli);
  683.           break;
  684.       case EnterNotify:
  685.           if (GRV.FocusFollowsMouse &&
  686. --- 644,705 ----
  687.       case Expose:
  688.           PaintVirtualWindow(dpy, ev);
  689.           break;
  690. ! 
  691. !     case MotionNotify:
  692. !         if (XFindContext(dpy, ev->xany.window, VirtualContext, &cli) != 0)
  693. !         return;
  694. !         TranslateVirtualCoords(dpy, &ev->xmotion.x_root,
  695. !             &ev->xmotion.y_root, &ev->xmotion.x, &ev->xmotion.y);
  696. !         if (cli->wmState == IconicState) {
  697. !         ev->xany.window = cli->iconwin->core.self;
  698. !             GFrameEventMotionNotify(dpy, ev, cli->iconwin);
  699. !         }
  700. !         else {
  701. !         ev->xany.window = cli->framewin->core.self;
  702. !         GFrameEventMotionNotify(dpy, ev, cli->framewin);
  703. !         }
  704. !         break;
  705. ! 
  706. !     case ButtonRelease:
  707. !         if (XFindContext(dpy, ev->xany.window, VirtualContext, &cli) != 0)
  708. !         return;
  709.           /*
  710. !          * We translate events for adjust and select so that those
  711. !          * routines will think we actually selected on the frame.  But
  712. !          * we don't do that for menus, because we want the menu to come
  713. !          * up in the absolute place
  714.            */
  715. !         if (MouseButton(dpy, ev) == MB_MENU)
  716. !             TranslateVirtualCoords(dpy, NULL, NULL,
  717. !                 &ev->xbutton.x, &ev->xbutton.y);
  718. !         else TranslateVirtualCoords(dpy, &ev->xbutton.x_root,
  719. !             &ev->xbutton.y_root, &ev->xbutton.x, &ev->xbutton.y);
  720. !         if (cli->wmState == IconicState) {
  721. !         ev->xany.window = cli->iconwin->core.self;
  722. !             GFrameEventButtonRelease(dpy, ev, cli->iconwin);
  723. !         }
  724. !         else {
  725. !         ev->xany.window = cli->framewin->core.self;
  726. !         GFrameEventButtonRelease(dpy, ev, cli->framewin);
  727. !         }
  728. !         break;
  729. ! 
  730. !     case ButtonPress:
  731.           if (XFindContext(dpy, ev->xany.window, VirtualContext, &cli) != 0)
  732.           return;
  733. !         if (MouseButton(dpy, ev) == MB_MENU)
  734. !             TranslateVirtualCoords(dpy, NULL, NULL,
  735. !                 &ev->xbutton.x, &ev->xbutton.y);
  736. !         else TranslateVirtualCoords(dpy, &ev->xbutton.x_root,
  737. !             &ev->xbutton.y_root, &ev->xbutton.x, &ev->xbutton.y);
  738. !         if (cli->wmState == IconicState) {
  739. !         ev->xany.window = cli->iconwin->core.self;
  740. !             GFrameEventButtonPress(dpy, ev, cli->iconwin);
  741. !         }
  742. !         else {
  743. !         ev->xany.window = cli->framewin->core.self;
  744. !         GFrameEventButtonPress(dpy, ev, cli->framewin);
  745. !         }
  746.           break;
  747.       case EnterNotify:
  748.           if (GRV.FocusFollowsMouse &&
  749. ***************
  750. *** 497,502 ****
  751. --- 708,716 ----
  752.               RevertToPointerRoot, CurrentTime);
  753.           }
  754.           break;
  755. +     case DestroyNotify:
  756. +         VWList = ListDestroyCellByValue(ev->xany.window, VWList);
  757. +         break;
  758.       }
  759.   }
  760.   
  761. ***************
  762. *** 509,544 ****
  763.   int    doit = FALSE;
  764.   int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  765.   int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  766.   KeySym    symbol;
  767.   enum st_retval ReplaceSticky();
  768.   
  769.       deltas.delta_x = deltas.delta_y = 0;
  770.       symbol = XLookupKeysym(ev, 0);
  771.       switch(symbol) {
  772.       case XK_Left:
  773. !         deltas.delta_x = -dw;
  774.           doit = TRUE;
  775.           break;
  776.       case XK_Up:
  777. !         deltas.delta_y = -dh;
  778.           doit = TRUE;
  779.           break;
  780.       case XK_Right:
  781. !         deltas.delta_x = dw;
  782.           doit = TRUE;
  783.           break;
  784.       case XK_Down:
  785. !         deltas.delta_y = dh;
  786.           doit = TRUE;
  787.           break;
  788.       case XK_R7:
  789. !         deltas.delta_x = -dw;
  790. !         deltas.delta_y = -dh;
  791.           doit = TRUE;
  792.           break;
  793.       case XK_R9:
  794. !         deltas.delta_x = dw;
  795. !         deltas.delta_y = -dh;
  796.           doit = TRUE;
  797.           break;
  798.       case XK_R11:
  799. --- 723,778 ----
  800.   int    doit = FALSE;
  801.   int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  802.   int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  803. + int    screen;
  804. + double    factor;
  805.   KeySym    symbol;
  806.   enum st_retval ReplaceSticky();
  807.   
  808. +     if (ev->xkey.type != KeyPress)
  809. +     return;        /* Root window uses same function for Up and Down events */
  810.       deltas.delta_x = deltas.delta_y = 0;
  811.       symbol = XLookupKeysym(ev, 0);
  812. + 
  813. +     switch(ev->xkey.state & (ShiftMask|ControlMask)) {
  814. +     case ShiftMask:
  815. +         factor = 2;
  816. +         break;
  817. +     case ControlMask:
  818. +         factor = .5;
  819. +         break;
  820. +     case ShiftMask|ControlMask:
  821. +         factor = 20;
  822. +         break;
  823. +     default:
  824. +         factor = 1;
  825. +         break;
  826. +     }
  827. + 
  828.       switch(symbol) {
  829.       case XK_Left:
  830. !         deltas.delta_x = -dw * factor;
  831.           doit = TRUE;
  832.           break;
  833.       case XK_Up:
  834. !         deltas.delta_y = -dh * factor;
  835.           doit = TRUE;
  836.           break;
  837.       case XK_Right:
  838. !         deltas.delta_x = dw * factor;
  839.           doit = TRUE;
  840.           break;
  841.       case XK_Down:
  842. !         deltas.delta_y = dh * factor;
  843.           doit = TRUE;
  844.           break;
  845.       case XK_R7:
  846. !         deltas.delta_x = -dw * factor;
  847. !         deltas.delta_y = -dh * factor;
  848.           doit = TRUE;
  849.           break;
  850.       case XK_R9:
  851. !         deltas.delta_x = dw * factor;
  852. !         deltas.delta_y = -dh * factor;
  853.           doit = TRUE;
  854.           break;
  855.       case XK_R11:
  856. ***************
  857. *** 547,586 ****
  858.           doit = TRUE;
  859.           break;
  860.       case XK_R13:
  861. !         deltas.delta_x = -dw;
  862. !         deltas.delta_y = dh;
  863.           doit = TRUE;
  864.           break;
  865.       case XK_R15:
  866. !         deltas.delta_x = dw;
  867. !         deltas.delta_y = dh;
  868.           doit = TRUE;
  869.           break;
  870.       default:
  871.           break;
  872.       }
  873.       if (!doit)
  874.       return FALSE;
  875.   
  876. !     if (VirtualDesktopX - deltas.delta_x < dw - VirtualDesktopWidth)
  877. !     deltas.delta_x = VirtualDesktopX + VirtualDesktopWidth - dw;
  878. !     else if (VirtualDesktopX - deltas.delta_x > 0)
  879. !     deltas.delta_x = VirtualDesktopX;
  880. !     if (VirtualDesktopY - deltas.delta_y < dh - VirtualDesktopHeight)
  881. !     deltas.delta_y = VirtualDesktopY + VirtualDesktopHeight - dh;
  882. !     else if (VirtualDesktopY - deltas.delta_y > 0)
  883. !     deltas.delta_y = VirtualDesktopY;
  884.   
  885.       if (fabs(deltas.delta_x) < 0.1 && fabs(deltas.delta_y) < 0.1)
  886.       return FALSE;
  887. ! 
  888. !     VDMOutlineX = (-VirtualDesktopX + deltas.delta_x) / GRV.VDMScale;
  889. !     VDMOutlineY = (-VirtualDesktopY + deltas.delta_y) / GRV.VDMScale;
  890. ! 
  891.       MoveDesktop(dpy, &deltas);
  892.       return TRUE;
  893.   }
  894.   
  895.   MoveDesktop(dpy, deltas)
  896.       Display    *dpy;
  897.       struct deltas    *deltas;
  898. --- 781,861 ----
  899.           doit = TRUE;
  900.           break;
  901.       case XK_R13:
  902. !         deltas.delta_x = -dw * factor;
  903. !         deltas.delta_y = dh * factor;
  904.           doit = TRUE;
  905.           break;
  906.       case XK_R15:
  907. !         deltas.delta_x = dw * factor;
  908. !         deltas.delta_y = dh * factor;
  909.           doit = TRUE;
  910.           break;
  911.       default:
  912.           break;
  913.       }
  914. +     if (!doit && symbol >= XK_F1 && symbol <= XK_F10) {
  915. +         switch(ev->xkey.state & (ShiftMask|ControlMask)) {
  916. +         case ShiftMask:
  917. +             factor = 2;
  918. +             break;
  919. +         case ControlMask:
  920. +             factor = 1;
  921. +             break;
  922. +         case ShiftMask|ControlMask:
  923. +             factor = 3;
  924. +             break;
  925. +         default:
  926. +             factor = 0;
  927. +             break;
  928. +         }
  929. +     doit = TRUE;
  930. +     deltas.delta_x = VirtualDesktopX;
  931. +     deltas.delta_y = VirtualDesktopY;
  932. +     screen = symbol - XK_F1 + 10 * factor;
  933. +     deltas.delta_x += dw * (screen % VDMCols);
  934. +     deltas.delta_y += dh * (screen / VDMCols);
  935. +     }
  936.       if (!doit)
  937.       return FALSE;
  938.   
  939. !     constrain_deltas(dpy, &deltas);
  940.   
  941.       if (fabs(deltas.delta_x) < 0.1 && fabs(deltas.delta_y) < 0.1)
  942.       return FALSE;
  943. !     MoveVDMOutline(dpy, &deltas);
  944.       MoveDesktop(dpy, &deltas);
  945.       return TRUE;
  946.   }
  947.   
  948. + MoveVDMOutline(dpy, deltas)
  949. +     Display    *dpy;
  950. +     struct deltas    *deltas;
  951. + {
  952. +     if (deltas->delta_x < 0)
  953. +         VDMOutlineX -= ceil(-deltas->delta_x / GRV.VDMScale);
  954. +     else VDMOutlineX += ceil(deltas->delta_x / GRV.VDMScale);
  955. +     if (deltas->delta_y < 0)
  956. +         VDMOutlineY -= ceil(-deltas->delta_y / GRV.VDMScale);
  957. +     else VDMOutlineY += ceil(deltas->delta_y / GRV.VDMScale);
  958. + }
  959. + 
  960. + constrain_deltas(dpy, deltas)
  961. +     Display        *dpy;
  962. +     struct deltas    *deltas;
  963. + {
  964. + int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  965. + int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  966. + 
  967. +     if (VirtualDesktopX - deltas->delta_x < dw - VirtualDesktopWidth)
  968. +     deltas->delta_x = VirtualDesktopX + VirtualDesktopWidth - dw;
  969. +     else if (VirtualDesktopX - deltas->delta_x > 0)
  970. +     deltas->delta_x = VirtualDesktopX;
  971. +     if (VirtualDesktopY - deltas->delta_y < dh - VirtualDesktopHeight)
  972. +     deltas->delta_y = VirtualDesktopY + VirtualDesktopHeight - dh;
  973. +     else if (VirtualDesktopY - deltas->delta_y > 0)
  974. +     deltas->delta_y = VirtualDesktopY;
  975. + }
  976. + 
  977.   MoveDesktop(dpy, deltas)
  978.       Display    *dpy;
  979.       struct deltas    *deltas;
  980. ***************
  981. *** 590,595 ****
  982. --- 865,873 ----
  983.   
  984.       VirtualDesktopX -= deltas->delta_x;
  985.       VirtualDesktopY -= deltas->delta_y;
  986. +     VDMOutlineX = ceil((double) -VirtualDesktopX / GRV.VDMScale);
  987. +     VDMOutlineY = ceil((double) -VirtualDesktopY / GRV.VDMScale);
  988. +     DrawVDMGrid(dpy);
  989.       WIApply(ReplaceSticky, deltas);
  990.       event.xexpose.count = 0;
  991.       HandleVDMExpose(dpy, &event);
  992. ***************
  993. *** 659,664 ****
  994. --- 937,944 ----
  995.   int    VDMPointerX = -1;
  996.   int    VDMPointerY;
  997.   int    VDMInitX, VDMInitY;
  998. + int    VDMLastSelectTime = 0;
  999. + int    NumVDMMoves = 0;
  1000.   
  1001.   HandleVDMButtonPress(dpy, ev)
  1002.       Display    *dpy;
  1003. ***************
  1004. *** 667,685 ****
  1005.   {
  1006.       VDMPointerX = ev->xbutton.x;
  1007.       VDMPointerY = ev->xbutton.y;
  1008. !     if (VDMPointerX < VDMOutlineX ||
  1009. !             VDMPointerX > VDMOutlineX + VDMOutlineWidth)
  1010. !     return FALSE;
  1011. !     if (VDMPointerY < VDMOutlineY ||
  1012. !             VDMPointerY > VDMOutlineY + VDMOutlineHeight)
  1013. !     return FALSE;
  1014. !     XClearWindow(dpy, VDM);
  1015.       XDrawRectangle(dpy, VDM, VDMGC,
  1016.       VDMOutlineX, VDMOutlineY,
  1017.       VDMOutlineWidth, VDMOutlineHeight);
  1018.       VDMInitX = VDMOutlineX;
  1019.       VDMInitY = VDMOutlineY;
  1020. !     return TRUE;
  1021.   }
  1022.   
  1023.   HandleVDMButtonRelease(dpy, ev)
  1024. --- 947,960 ----
  1025.   {
  1026.       VDMPointerX = ev->xbutton.x;
  1027.       VDMPointerY = ev->xbutton.y;
  1028. !     XSetFunction(dpy, VDMGC, GXxor);
  1029.       XDrawRectangle(dpy, VDM, VDMGC,
  1030.       VDMOutlineX, VDMOutlineY,
  1031.       VDMOutlineWidth, VDMOutlineHeight);
  1032.       VDMInitX = VDMOutlineX;
  1033.       VDMInitY = VDMOutlineY;
  1034. !     NumVDMMoves = 0;
  1035. !     return True;
  1036.   }
  1037.   
  1038.   HandleVDMButtonRelease(dpy, ev)
  1039. ***************
  1040. *** 688,696 ****
  1041.   
  1042.   {
  1043.   struct deltas    deltas;
  1044.   
  1045. !     XClearWindow(dpy, VDM);
  1046. !     constrain_vdm_outline(ev->xbutton.x, ev->xbutton.y);
  1047.       XDrawRectangle(dpy, VDM, VDMGC, VDMOutlineX, VDMOutlineY,
  1048.       VDMOutlineWidth, VDMOutlineHeight);
  1049.       deltas.delta_x = (VDMOutlineX - VDMInitX) * GRV.VDMScale;
  1050. --- 963,994 ----
  1051.   
  1052.   {
  1053.   struct deltas    deltas;
  1054. + int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  1055. + int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  1056.   
  1057. !     XDrawRectangle(dpy, VDM, VDMGC,
  1058. !     VDMOutlineX, VDMOutlineY,
  1059. !     VDMOutlineWidth, VDMOutlineHeight);
  1060. !     XSetFunction(dpy, VDMGC, GXcopy);
  1061. ! 
  1062. !     if (ev->xbutton.time - VDMLastSelectTime <= GRV.DoubleClickTime) {
  1063. !     deltas.delta_x = VirtualDesktopX;
  1064. !     deltas.delta_y = VirtualDesktopY;
  1065. !     deltas.delta_x += dw * (ev->xbutton.x / VDMOutlineWidth);
  1066. !     deltas.delta_y += dh * (ev->xbutton.y / VDMOutlineHeight);
  1067. !     constrain_deltas(dpy, &deltas);
  1068. !     MoveVDMOutline(dpy, &deltas);
  1069. !     MoveDesktop(dpy, &deltas);
  1070. !     return False;
  1071. !     }
  1072. !     VDMLastSelectTime = ev->xbutton.time;
  1073. ! 
  1074. !     if (!NumVDMMoves)
  1075. !     return;
  1076. !     constrain_vdm_outline(ev->xbutton.x, ev->xbutton.y,
  1077. !         (GRV.VirtualGrid) ? !(ev->xbutton.state & ControlMask) :
  1078. !                       (ev->xbutton.state & ControlMask));
  1079. !     DrawVDMGrid(dpy);
  1080.       XDrawRectangle(dpy, VDM, VDMGC, VDMOutlineX, VDMOutlineY,
  1081.       VDMOutlineWidth, VDMOutlineHeight);
  1082.       deltas.delta_x = (VDMOutlineX - VDMInitX) * GRV.VDMScale;
  1083. ***************
  1084. *** 706,735 ****
  1085.   {
  1086.       if (VDMPointerX == -1)
  1087.       return;
  1088. -     XClearWindow(dpy, VDM);
  1089. -     constrain_vdm_outline(ev->xmotion.x, ev->xmotion.y);
  1090. - 
  1091.       XDrawRectangle(dpy, VDM, VDMGC,
  1092.       VDMOutlineX, VDMOutlineY,
  1093.       VDMOutlineWidth, VDMOutlineHeight);
  1094.   }
  1095.   
  1096. ! constrain_vdm_outline(x, y)
  1097. !     int x, y;
  1098.   
  1099.   {
  1100. !     VDMOutlineX = x - VDMPointerX + VDMInitX;
  1101. !     VDMOutlineY = y - VDMPointerY + VDMInitY;
  1102.       
  1103.       if (VDMOutlineX < 0)
  1104.       VDMOutlineX = 0;
  1105. !     else if (VDMOutlineX + VDMOutlineWidth >= VDMWidth)
  1106. !     VDMOutlineX = VDMWidth - VDMOutlineWidth - 1;
  1107.   
  1108.       if (VDMOutlineY < 0)
  1109.       VDMOutlineY = 0;
  1110. !     else if (VDMOutlineY + VDMOutlineHeight >= VDMHeight)
  1111. !     VDMOutlineY = VDMHeight - VDMOutlineHeight - 1;
  1112.   }
  1113.   
  1114.   int    SaveVDX = -1, SaveVDY;
  1115. --- 1004,1043 ----
  1116.   {
  1117.       if (VDMPointerX == -1)
  1118.       return;
  1119.       XDrawRectangle(dpy, VDM, VDMGC,
  1120.       VDMOutlineX, VDMOutlineY,
  1121.       VDMOutlineWidth, VDMOutlineHeight);
  1122. +     constrain_vdm_outline(ev->xmotion.x, ev->xmotion.y,
  1123. +         (GRV.VirtualGrid) ? !(ev->xbutton.state & ControlMask) :
  1124. +                       (ev->xbutton.state & ControlMask));
  1125. +     XDrawRectangle(dpy, VDM, VDMGC,
  1126. +     VDMOutlineX, VDMOutlineY,
  1127. +     VDMOutlineWidth, VDMOutlineHeight);
  1128. +     NumVDMMoves++;
  1129.   }
  1130.   
  1131. ! constrain_vdm_outline(x, y, snap)
  1132. !     int x, y, snap;
  1133.   
  1134.   {
  1135. !     if (snap) {
  1136. !     VDMOutlineX = (x / VDMOutlineWidth) * VDMOutlineWidth;
  1137. !     VDMOutlineY = (y / VDMOutlineHeight) * VDMOutlineHeight;
  1138. !     }
  1139. !     else {
  1140. !         VDMOutlineX = x - VDMPointerX + VDMInitX;
  1141. !         VDMOutlineY = y - VDMPointerY + VDMInitY;
  1142. !     }
  1143.       
  1144.       if (VDMOutlineX < 0)
  1145.       VDMOutlineX = 0;
  1146. !     else if (VDMOutlineX + VDMOutlineWidth > VDMWidth)
  1147. !     VDMOutlineX = VDMWidth - VDMOutlineWidth;
  1148.   
  1149.       if (VDMOutlineY < 0)
  1150.       VDMOutlineY = 0;
  1151. !     else if (VDMOutlineY + VDMOutlineHeight > VDMHeight)
  1152. !     VDMOutlineY = VDMHeight - VDMOutlineHeight;
  1153.   }
  1154.   
  1155.   int    SaveVDX = -1, SaveVDY;
  1156. ***************
  1157. *** 783,803 ****
  1158.   Client    *cli;
  1159.   
  1160.       if (isUpdate) {
  1161. !         sscanf(GRV.VirtualDesktop, "%dx%d", &width, &height);
  1162. !         if (width < DisplayWidth(dpy,DefaultScreen(dpy)))
  1163. !            width = width * DisplayWidth(dpy,DefaultScreen(dpy));
  1164. !         if (height < DisplayHeight(dpy,DefaultScreen(dpy)))
  1165. !            height = height * DisplayHeight(dpy,DefaultScreen(dpy));
  1166.       if (XFindContext(dpy, VDM, VirtualContext, &cli) != 0)
  1167. !         return TRUE;
  1168. !         GFrameSetConfig(cli->framewin, (int) cli->framewin->core.x,
  1169. !         (int) cli->framewin->core.y,
  1170. !         width / GRV.VDMScale + 1 +
  1171. !         widthLeftFrame(cli->framewin) + widthRightFrame(cli->framewin),
  1172. !         height / GRV.VDMScale + 1 +
  1173. !         heightTopFrame(cli->framewin) + heightBottomFrame(cli->framewin));
  1174.       }
  1175. !     return TRUE;
  1176.   }
  1177.   
  1178.   Bool
  1179. --- 1091,1102 ----
  1180.   Client    *cli;
  1181.   
  1182.       if (isUpdate) {
  1183. !     MakeVirtualDesktop(dpy);
  1184.       if (XFindContext(dpy, VDM, VirtualContext, &cli) != 0)
  1185. !         return True;
  1186. !     ResizeProgVirtual(dpy, cli);
  1187.       }
  1188. !     return True;
  1189.   }
  1190.   
  1191.   Bool
  1192. ***************
  1193. *** 919,925 ****
  1194.   {
  1195.       if (isUpdate) {
  1196.       XSetWindowBackground(dpy, VDM, GRV.VirtualBackgroundColor);
  1197. !     XClearWindow(dpy, VDM);
  1198.       }
  1199.       return TRUE;
  1200.   }
  1201. --- 1218,1224 ----
  1202.   {
  1203.       if (isUpdate) {
  1204.       XSetWindowBackground(dpy, VDM, GRV.VirtualBackgroundColor);
  1205. !         DrawVDMGrid(dpy);
  1206.       }
  1207.       return TRUE;
  1208.   }
  1209. ***************
  1210. *** 973,979 ****
  1211.       if (isUpdate) {
  1212.       if (write = CreateVirtualPixmap(dpy)) {
  1213.           XSetWindowBackgroundPixmap(dpy, VDM, write);
  1214. !         XClearWindow(dpy, VDM);
  1215.           XFreePixmap(dpy, write);
  1216.       }
  1217.       }
  1218. --- 1272,1278 ----
  1219.       if (isUpdate) {
  1220.       if (write = CreateVirtualPixmap(dpy)) {
  1221.           XSetWindowBackgroundPixmap(dpy, VDM, write);
  1222. !             DrawVDMGrid(dpy);
  1223.           XFreePixmap(dpy, write);
  1224.       }
  1225.       }
  1226. ***************
  1227. *** 987,992 ****
  1228. --- 1286,1292 ----
  1229.   Pixmap    read, write;
  1230.   int    w, h, dummy;
  1231.   GC    gc;
  1232. + XGCValues    gcv;
  1233.   
  1234.       if (XReadBitmapFile(dpy, RootWindow(dpy, DefaultScreen(dpy)),
  1235.               GRV.VirtualBackgroundMap, &w, &h,
  1236. ***************
  1237. *** 993,1005 ****
  1238.               &read, &dummy, &dummy) == BitmapSuccess) {
  1239.       write = XCreatePixmap(dpy, RootWindow(dpy, DefaultScreen(dpy)),
  1240.               w, h, DefaultDepth(dpy, DefaultScreen(dpy)));
  1241. !     gc = XCreateGC(dpy, VDM, 0, NULL);
  1242.           XCopyGC(dpy, VDMGC, GCForeground | GCBackground, gc);
  1243. !     /*
  1244. !      * Why doesn't this color stuff work on startup?
  1245. !      */
  1246. !     if (VirtualForegroundColorSet)
  1247. !         XSetForeground(dpy, gc, GRV.VirtualForegroundColor);
  1248.       if (VirtualBackgroundColorSet)
  1249.           XSetBackground(dpy, gc, GRV.VirtualBackgroundColor);
  1250.       XCopyPlane(dpy, read, write, gc, 0, 0, w, h, 0, 0, 1);
  1251. --- 1293,1302 ----
  1252.               &read, &dummy, &dummy) == BitmapSuccess) {
  1253.       write = XCreatePixmap(dpy, RootWindow(dpy, DefaultScreen(dpy)),
  1254.               w, h, DefaultDepth(dpy, DefaultScreen(dpy)));
  1255. !     gcv.function = GXcopy;
  1256. !     gc = XCreateGC(dpy, VDM, GCFunction, &gcv);
  1257.           XCopyGC(dpy, VDMGC, GCForeground | GCBackground, gc);
  1258. !     XSetForeground(dpy, gc, GRV.VirtualPixmapColor);
  1259.       if (VirtualBackgroundColorSet)
  1260.           XSetBackground(dpy, gc, GRV.VirtualBackgroundColor);
  1261.       XCopyPlane(dpy, read, write, gc, 0, 0, w, h, 0, 0, 1);
  1262. ***************
  1263. *** 1019,1059 ****
  1264.   int    doit;
  1265.   struct deltas    deltas;
  1266.   int    temp;
  1267.   
  1268. !     VirtualDesktopHeight = (height - 1) * GRV.VDMScale;
  1269. !     VirtualDesktopWidth = (width - 1) * GRV.VDMScale;
  1270. !     temp = nint((double) VirtualDesktopHeight / 
  1271. !         (double) DisplayHeight(dpy, DefaultScreen(dpy))) *
  1272. !         DisplayHeight(dpy, DefaultScreen(dpy));
  1273. !     if (abs(temp - VirtualDesktopHeight) <= GRV.VDMScale)
  1274. !     VirtualDesktopHeight = temp;
  1275. !     temp = nint((double) VirtualDesktopWidth / 
  1276. !         (double) DisplayWidth(dpy, DefaultScreen(dpy))) *
  1277. !         DisplayWidth(dpy, DefaultScreen(dpy));
  1278. !     if (abs(temp - VirtualDesktopWidth) <= GRV.VDMScale)
  1279. !     VirtualDesktopWidth = temp;
  1280. !     VDMWidth = width;
  1281. !     VDMHeight = height;
  1282.       doit = FALSE;
  1283.       deltas.delta_x = deltas.delta_y = 0;
  1284. !     if (VDMOutlineX + VDMOutlineWidth > VDMWidth - 1) {
  1285.       doit = TRUE;
  1286. !     deltas.delta_x = (VDMWidth - VDMOutlineWidth - 1 -
  1287.           VDMOutlineX) * GRV.VDMScale;
  1288. !         VDMOutlineX = (-VirtualDesktopX + deltas.delta_x) /
  1289. !                 GRV.VDMScale;
  1290.       }
  1291. !     if (VDMOutlineY + VDMOutlineHeight > VDMHeight - 1) {
  1292.       doit = TRUE;
  1293. !     deltas.delta_y = (VDMHeight - VDMOutlineHeight - 1 -
  1294.           VDMOutlineY) * GRV.VDMScale;
  1295. !         VDMOutlineY = (-VirtualDesktopY + deltas.delta_y) /
  1296. !                 GRV.VDMScale;
  1297.       }
  1298.       if (doit) {
  1299.           MoveDesktop(dpy, &deltas);
  1300.              RecursiveRefresh(dpy, VDM);
  1301. !    }
  1302.   }
  1303.   
  1304.   Bool
  1305. --- 1316,1365 ----
  1306.   int    doit;
  1307.   struct deltas    deltas;
  1308.   int    temp;
  1309. + int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  1310. + int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  1311.   
  1312. !     if (GRV.VirtualGrid) {
  1313. !         VirtualDesktopHeight = (height - 3) * GRV.VDMScale;
  1314. !         VirtualDesktopHeight = ((VirtualDesktopHeight - 1) / dh + 1) * dh;
  1315. !         VirtualDesktopWidth = (width - 3) * GRV.VDMScale;
  1316. !         VirtualDesktopWidth = ((VirtualDesktopWidth - 1) / dw + 1) * dw;
  1317. !         VDMRows = ceil((double) VirtualDesktopHeight / dh);
  1318. !         VDMCols = ceil((double) VirtualDesktopWidth / dw);
  1319. !         VDMWidth = VDMCols * VDMOutlineWidth;
  1320. !         VDMHeight = VDMRows * VDMOutlineHeight;
  1321. !     }
  1322. !     else {
  1323. !     VirtualDesktopHeight = height * GRV.VDMScale;
  1324. !     VirtualDesktopWidth = width * GRV.VDMScale;
  1325. !         VDMRows = ceil((double) VirtualDesktopHeight / dh);
  1326. !         VDMCols = ceil((double) VirtualDesktopWidth / dw);
  1327. !     VDMWidth = width;
  1328. !     VDMHeight = height;
  1329. !     }
  1330.       doit = FALSE;
  1331.       deltas.delta_x = deltas.delta_y = 0;
  1332. !     if (VDMOutlineX + VDMOutlineWidth > VDMWidth) {
  1333.       doit = TRUE;
  1334. !     deltas.delta_x = (VDMWidth - VDMOutlineWidth -
  1335.           VDMOutlineX) * GRV.VDMScale;
  1336. !         if (deltas.delta_x < 0)
  1337. !             VDMOutlineX -= ceil(-deltas.delta_x / GRV.VDMScale);
  1338. !         else VDMOutlineX += ceil(deltas.delta_x / GRV.VDMScale);
  1339.       }
  1340. !     if (VDMOutlineY + VDMOutlineHeight > VDMHeight) {
  1341.       doit = TRUE;
  1342. !     deltas.delta_y = (VDMHeight - VDMOutlineHeight -
  1343.           VDMOutlineY) * GRV.VDMScale;
  1344. !         if (deltas.delta_y < 0)
  1345. !             VDMOutlineY -= ceil(-deltas.delta_y / GRV.VDMScale);
  1346. !         else VDMOutlineY += ceil(deltas.delta_y / GRV.VDMScale);
  1347.       }
  1348.       if (doit) {
  1349.           MoveDesktop(dpy, &deltas);
  1350.              RecursiveRefresh(dpy, VDM);
  1351. !     }
  1352. !     DrawVDMGrid(dpy);
  1353.   }
  1354.   
  1355.   Bool
  1356. ***************
  1357. *** 1090,1096 ****
  1358.           cli->iconwin->core.width, cli->iconwin->core.height);
  1359.       }
  1360.       }
  1361. !     return TRUE;
  1362.   }
  1363.   
  1364.   VirtualSetColor( dpy, rmIndex, newValue, varSet )
  1365. --- 1396,1402 ----
  1366.           cli->iconwin->core.width, cli->iconwin->core.height);
  1367.       }
  1368.       }
  1369. !     return True;
  1370.   }
  1371.   
  1372.   VirtualSetColor( dpy, rmIndex, newValue, varSet )
  1373. ***************
  1374. *** 1105,1109 ****
  1375. --- 1411,1568 ----
  1376.       VirtualForegroundColorSet = TRUE;
  1377.       else if (rmIndex == RM_VIRTUALFONTCOLOR && newValue)
  1378.       VirtualFontColorSet = TRUE;
  1379. +     else if (rmIndex == RM_VIRTUALGRIDCOLOR && newValue)
  1380. +     VirtualGridColorSet = True;
  1381.       return setColor(dpy, rmIndex, newValue, varSet);
  1382. + }
  1383. + 
  1384. + TranslateVirtualCoords(dpy, root_x, root_y, x, y)
  1385. +     int    *root_x, *root_y, *x, *y;
  1386. + 
  1387. + {
  1388. + int    tx, ty, tw, th, bw, d;
  1389. + Window    root;
  1390. + 
  1391. +     if (x)
  1392. +         *x *= GRV.VDMScale;
  1393. +     if (y)
  1394. +         *y *= GRV.VDMScale;
  1395. +     if (!root_x || !root_y)
  1396. +     return;
  1397. +     XGetGeometry(dpy, VDMFrame, &root, &tx, &ty, &tw, &th, &bw, &d);
  1398. +     *root_x -= tx;
  1399. +     *root_y -= ty;
  1400. +     XGetGeometry(dpy, VDM, &root, &tx, &ty, &tw, &th, &bw, &d);
  1401. +     *root_x -= tx;
  1402. +     *root_y -= ty;
  1403. +     *root_x *= GRV.VDMScale;
  1404. +     *root_x += VirtualDesktopX;
  1405. +     *root_y *= GRV.VDMScale;
  1406. +     *root_y += VirtualDesktopY;
  1407. + }
  1408. + 
  1409. + SelectVirtual(cli, state)
  1410. +     Client    *cli;
  1411. +     Bool    state;
  1412. + 
  1413. + {
  1414. +     XSetWindowBorderWidth(cli->dpy, cli->virtualWindow, state ? 2 : 1);
  1415. +     XSetWindowBorderWidth(cli->dpy, cli->virtualInactive, state ? 2 : 1);
  1416. + }
  1417. + 
  1418. + static int
  1419. + VDMMenuAction(dpy, winInfo, menu, idx, pinnedMenu)
  1420. + Display *dpy;
  1421. + struct _wingeneric    *winInfo;
  1422. + Menu    *menu;
  1423. + int    idx;
  1424. + Bool    pinnedMenu;
  1425. + 
  1426. + {
  1427. + struct deltas    deltas;
  1428. + int    dw = DisplayWidth(dpy, DefaultScreen(dpy));
  1429. + int    dh = DisplayHeight(dpy, DefaultScreen(dpy));
  1430. + 
  1431. +     switch(idx) {
  1432. +     case VDM_MENU_LEFT:
  1433. +         deltas.delta_x = -dw;
  1434. +         break;
  1435. +     case VDM_MENU_UP:
  1436. +         deltas.delta_y = -dh;
  1437. +         break;
  1438. +     case VDM_MENU_RIGHT:
  1439. +         deltas.delta_x = dw;
  1440. +         break;
  1441. +     case VDM_MENU_DOWN:
  1442. +         deltas.delta_y = dh;
  1443. +         break;
  1444. +     case VDM_MENU_LEFT_UP:
  1445. +         deltas.delta_x = -dw;
  1446. +         deltas.delta_y = -dh;
  1447. +         break;
  1448. +     case VDM_MENU_RIGHT_UP:
  1449. +         deltas.delta_x = dw;
  1450. +         deltas.delta_y = -dh;
  1451. +         break;
  1452. +     case VDM_MENU_HOME:
  1453. +         deltas.delta_x = VirtualDesktopX;
  1454. +         deltas.delta_y = VirtualDesktopY;
  1455. +         break;
  1456. +     case VDM_MENU_LEFT_DOWN:
  1457. +         deltas.delta_x = -dw;
  1458. +         deltas.delta_y = dh;
  1459. +         break;
  1460. +     case VDM_MENU_RIGHT_DOWN:
  1461. +         deltas.delta_x = dw;
  1462. +         deltas.delta_y = dh;
  1463. +         break;
  1464. +     }
  1465. +     constrain_deltas(dpy, &deltas);
  1466. + 
  1467. +     if (fabs(deltas.delta_x) < 0.1 && fabs(deltas.delta_y) < 0.1)
  1468. +     return FALSE;
  1469. +     MoveVDMOutline(dpy, &deltas);
  1470. +     MoveDesktop(dpy, &deltas);
  1471. + }
  1472. + 
  1473. + Bool
  1474. + UpdVirtualGrid(dpy, rmIndex, isUpdate)
  1475. +     Display    *dpy;
  1476. +     int        rmIndex;
  1477. +     Bool    isUpdate;
  1478. + 
  1479. + {
  1480. + Client    *cli;
  1481. + 
  1482. +     if (isUpdate) {
  1483. +     cli = VirtualGetClient(dpy, VDM);
  1484. +     if (!cli)
  1485. +         return True;
  1486. +     ResizeVDM(dpy, 
  1487. +         cli->framewin->core.width -
  1488. +           widthLeftFrame(cli->framewin) - widthRightFrame(cli->framewin),
  1489. +         cli->framewin->core.height -
  1490. +           heightTopFrame(cli->framewin) - heightBottomFrame(cli->framewin));
  1491. +     if (GRV.VirtualGrid) {
  1492. +         cli->normHints->flags |= PResizeInc;
  1493. +         ResizeProgVirtual(dpy, cli);
  1494. +     }
  1495. +     else cli->normHints->flags &= ~PResizeInc;
  1496. +     }
  1497. +     DrawVDMGrid(dpy);
  1498. +     return True;
  1499. + }
  1500. + 
  1501. + ResizeProgVirtual(dpy, cli)
  1502. + Display    *dpy;
  1503. + Client    *cli;
  1504. + 
  1505. + {
  1506. +     GFrameSetConfig(cli->framewin,
  1507. +     cli->framewin->core.x, cli->framewin->core.y,
  1508. +     VDMWidth + widthLeftFrame(cli->framewin) +
  1509. +             widthRightFrame(cli->framewin),
  1510. +     VDMHeight + heightTopFrame(cli->framewin) +
  1511. +             heightBottomFrame(cli->framewin));
  1512. + }
  1513. + 
  1514. + SetGridResource(dpy, rmIndex, newValue, varSet)
  1515. + Display    *dpy;
  1516. + int    rmIndex;
  1517. + char    *newValue;
  1518. + Bool    varSet;
  1519. + 
  1520. + {
  1521. + int    new, ret;
  1522. + 
  1523. +     if (!newValue)
  1524. +     new = 2;
  1525. +     else if (matchString(newValue, "none"))
  1526. +     new = 0;
  1527. +     else if (matchString(newValue, "invisible"))
  1528. +     new = 1;
  1529. +     else new = 2;
  1530. +     ret = new != GRV.VirtualGrid;
  1531. +     GRV.VirtualGrid = new;
  1532. +     return ret;
  1533.   }
  1534. *** build/win.c    Sat Jun 22 20:09:02 1991
  1535. --- src/win.c    Sat Jun 22 20:56:18 1991
  1536. ***************
  1537. *** 6,12 ****
  1538.    *    Written for Sun Microsystems by Crucible, Santa Cruz, CA.
  1539.    */
  1540.   
  1541. ! static char     sccsid[] = "@(#)win.c    1.2 olvwm version 3/30/91";
  1542.   
  1543.   /*
  1544.    * Based on
  1545. --- 6,12 ----
  1546.    *    Written for Sun Microsystems by Crucible, Santa Cruz, CA.
  1547.    */
  1548.   
  1549. ! static char     sccsid[] = "@(#)win.c    1.3 olvwm version 6/22/91";
  1550.   
  1551.   /*
  1552.    * Based on
  1553. ***************
  1554. *** 147,152 ****
  1555. --- 147,153 ----
  1556.           callSelectTree(cli->dpy, cli->framewin, sel);
  1557.       else if (cli->wmState == IconicState)
  1558.           callSelectTree(cli->dpy, cli->iconwin, sel);
  1559. +     SelectVirtual(cli, sel);
  1560.   }
  1561.   
  1562.   /* WinCallFocus - call a client's focus functions for the frame tree.
  1563. ***************
  1564. *** 157,166 ****
  1565. --- 158,179 ----
  1566.   WinGeneric *win;
  1567.   Bool focus;
  1568.   {
  1569. + XEvent    ev;
  1570. + 
  1571.       if (win == NULL)
  1572.           return;
  1573.       win->core.client->isFocus = focus;
  1574.       callFocusTree(win, focus);
  1575. +     if (!focus && XCheckWindowEvent(win->core.client->dpy,
  1576. +                 win->core.self, DestroyNotify, &ev)) {
  1577. +         /*
  1578. +          * When a window goes away, we get first the Focus event and
  1579. +          * then the destroy event -- so we have to mark the client
  1580. +          * as still having focus so StateWithdrawn will work ok
  1581. +          */
  1582. +         XPutBackEvent(win->core.client->dpy, &ev);
  1583. +         win->core.client->isFocus = 1;
  1584. +     }
  1585.   }
  1586.       
  1587.   /* WinCallDestroy - call a client's destroy functions for both the icon and
  1588. *** build/winframe.c    Sat Jun 22 20:09:44 1991
  1589. --- src/winframe.c    Sat Jun 22 20:56:19 1991
  1590. ***************
  1591. *** 6,12 ****
  1592.    *    Written for Sun Microsystems by Crucible, Santa Cruz, CA.
  1593.    */
  1594.   
  1595. ! static char     sccsid[] = "@(#)winframe.c    1.3 olvwm version 4/17/91";
  1596.   
  1597.   /*
  1598.    * Based on
  1599. --- 6,12 ----
  1600.    *    Written for Sun Microsystems by Crucible, Santa Cruz, CA.
  1601.    */
  1602.   
  1603. ! static char     sccsid[] = "@(#)winframe.c    1.4 olvwm version 6/22/91";
  1604.   
  1605.   /*
  1606.    * Based on
  1607. ***************
  1608. *** 1171,1181 ****
  1609.    * get the event, set the focus, and replay the event, thus passing the event
  1610.    * through.
  1611.    *
  1612. -  * SDO:  We seem to get the event anyway.  And grabbing the button seemed
  1613. -  *     to cause lots of problems anyway, due perhaps to the grab bugs
  1614. -  *     in xnews, but whatever; if the button press was destined for the
  1615. -  *     VDM, we never got the button up (or anything else . . .).  And
  1616. -  * 
  1617.    * REMIND we need to remove explicit reference to Buttons 1 and 2.
  1618.    */
  1619.   void
  1620. --- 1171,1176 ----
  1621. ***************
  1622. *** 1184,1190 ****
  1623.       Window win;
  1624.       Bool activate;
  1625.   {
  1626. - #ifdef NOTDEF
  1627.       if (!GRV.FocusFollowsMouse) {
  1628.       switch (cli->focusMode) {
  1629.       case Passive:
  1630. --- 1179,1184 ----
  1631. ***************
  1632. *** 1203,1209 ****
  1633.           break;
  1634.       }
  1635.       }
  1636. - #endif
  1637.   }
  1638.   
  1639.   
  1640. --- 1197,1202 ----
  1641.  
  1642. --
  1643. Dan Heller
  1644. O'Reilly && Associates       Z-Code Software    Comp-sources-x:
  1645. Senior Writer                President          comp-sources-x@uunet.uu.net
  1646. argv@ora.com                 argv@zipcode.com
  1647.